/*
 * bsp_uart.c
 *
 *  Created on: 2025 Mar 16
 *      Author: SFLY
 */
#include "bsp_uart.h"
#include <stdarg.h>
#include <string.h>

extern __interrupt void scibISR(void);

void Bsp_UART_PIN_Init(void)
{
    GPIO_MuxConfig(UART_TX_GPIO, UART_TX_GPIO_MUX, GPIO_PIN_TYPE_STD, GPIO_QUAL_ASYNC);
    GPIO_MuxConfig(UART_RX_GPIO, UART_RX_GPIO_MUX, GPIO_PIN_TYPE_STD, GPIO_QUAL_ASYNC);
}
void Bsp_UART_Init(void)
{
      Bsp_UART_PIN_Init();
      SysCtl_enablePeripheral(SYSCTL_PERIPH_CLK_SCIB);
      SCI_setConfig(UART_BASE, DEVICE_LSPCLK_FREQ, UART_BAUND,
          SCI_CONFIG_WLEN_8 | SCI_CONFIG_STOP_ONE | SCI_CONFIG_PAR_NONE);
      SCI_enableFIFO(UART_BASE);
      SCI_resetRxFIFO(UART_BASE);
      SCI_setFIFOInterruptLevel(UART_BASE, SCI_FIFO_TX0, SCI_FIFO_RX1);
      SCI_enableInterrupt(UART_BASE, SCI_INT_RXRDY);
      Interrupt_register(INT_SCIB, &scibISR);
      Interrupt_enable(INT_SCIB);
}


// 缓冲区
char buffer[BUFFER_SIZE];
int buffer_index = 0;



// 刷新缓冲区
void flush_buffer() {
    if (buffer_index > 0) {
        uart_send_string(buffer, buffer_index);
        buffer_index = 0;
    }
}

// 向缓冲区添加字符
void add_to_buffer(char c) {
    if (buffer_index >= BUFFER_SIZE - 1) {
        flush_buffer();
    }
    buffer[buffer_index++] = c;
    if (c == '\n') {
        flush_buffer();
    }
}

// 输出整数
void put_int(int num) {
    if (num < 0) {
        add_to_buffer('-');
        num = -num;
    }
    char temp[12];
    int index = 0;
    do {
        temp[index++] = num % 10 + '0';
        num /= 10;
    } while (num > 0);
    while (index > 0) {
        add_to_buffer(temp[--index]);
    }
}

// 输出浮点数，支持自定义小数点位数
void put_float(double num, int precision) {
    if (num < 0) {
        add_to_buffer('-');
        num = -num;
    }
    int integer_part = (int)num;
    put_int(integer_part);
    add_to_buffer('.');
    double decimal_part = num - integer_part;
    for (int i = 0; i < precision; i++) {
        decimal_part *= 10;
        int digit = (int)decimal_part;
        add_to_buffer(digit + '0');
        decimal_part -= digit;
    }
}

// 输出字符串
void put_string(const char *str) {
    while (*str) {
        add_to_buffer(*str++);
    }
}

// 假设这些辅助函数已经实现
int get_int_length(int num) {
    if (num == 0) return 1;
    int len = 0;
    if (num < 0) {
        len++;
        num = -num;
    }
    while (num) {
        len++;
        num /= 10;
    }
    return len;
}

int get_float_length(double num, int precision) {
    // 简单实现，实际需要考虑更多情况
    int int_part = (int)num;
    int int_len = get_int_length(int_part);
    return int_len + 1 + precision;  // 加上小数点和小数部分的长度
}


// 自定义 printf 函数
int printf(const char *format, ...) {
    va_list args;
    va_start(args, format);
    int count = 0;

    while (*format) {
        if (*format == '%') {
            format++;
            int left_align = 0;  // 左对齐标志，默认为右对齐
            int width = 0;       // 宽度说明符
            int precision = 9;   // 默认精度为 9 位小数

            // 检查是否有左对齐标志
            if (*format == '-') {
                left_align = 1;
                format++;
            }

            // 解析宽度说明符
            while (*format >= '0' && *format <= '9') {
                width = width * 10 + (*format - '0');
                format++;
            }

            // 解析精度说明符
            if (*format == '.') {
                format++;
                precision = 0;
                while (*format >= '0' && *format <= '9') {
                    precision = precision * 10 + (*format - '0');
                    format++;
                }
            }

            switch (*format) {
                case 'd': {
                    int num = va_arg(args, int);
                    int len = get_int_length(num);  // 假设这个函数可以获取整数的长度
                    int padding = width > len ? width - len : 0;
                    if (!left_align) {
                        for (int i = 0; i < padding; i++) {
                            add_to_buffer(' ');
                            count++;
                        }
                    }
                    put_int(num);
                    count += len;
                    if (left_align) {
                        for (int i = 0; i < padding; i++) {
                            add_to_buffer(' ');
                            count++;
                        }
                    }
                    break;
                }
                case 's': {
                    const char *str = va_arg(args, const char *);
                    int len = strlen(str);
                    int padding = width > len ? width - len : 0;
                    if (!left_align) {
                        for (int i = 0; i < padding; i++) {
                            add_to_buffer(' ');
                            count++;
                        }
                    }
                    put_string(str);
                    count += len;
                    if (left_align) {
                        for (int i = 0; i < padding; i++) {
                            add_to_buffer(' ');
                            count++;
                        }
                    }
                    break;
                }
                case 'c': {
                    char c = (char)va_arg(args, int);
                    int padding = width > 1 ? width - 1 : 0;
                    if (!left_align) {
                        for (int i = 0; i < padding; i++) {
                            add_to_buffer(' ');
                            count++;
                        }
                    }
                    add_to_buffer(c);
                    count++;
                    if (left_align) {
                        for (int i = 0; i < padding; i++) {
                            add_to_buffer(' ');
                            count++;
                        }
                    }
                    break;
                }
                case 'f': {
                    double num = va_arg(args, double);
                    int len = get_float_length(num, precision);  // 假设这个函数可以获取浮点数的长度
                    int padding = width > len ? width - len : 0;
                    if (!left_align) {
                        for (int i = 0; i < padding; i++) {
                            add_to_buffer(' ');
                            count++;
                        }
                    }
                    put_float(num, precision);
                    count += len;
                    if (left_align) {
                        for (int i = 0; i < padding; i++) {
                            add_to_buffer(' ');
                            count++;
                        }
                    }
                    break;
                }
                default:
                    add_to_buffer(*format);
                    count++;
                    break;
            }
        } else {
            add_to_buffer(*format);
            count++;
        }
        format++;
    }

    flush_buffer();
    va_end(args);
    return count;
}


//// 自定义 printf 函数
//int printf(const char *format, ...) {
//    va_list args;
//    va_start(args, format);
//    int count = 0;
//
//    while (*format) {
//        if (*format == '%') {
//            format++;
//            int precision = 9; // 默认精度为 7 位小数
//            if (*format == '.') {
//                format++;
//                precision = 0;
//                while (*format >= '0' && *format <= '9') {
//                    precision = precision * 10 + (*format - '0');
//                    format++;
//                }
//            }
//            switch (*format) {
//                case 'd': {
//                    int num = va_arg(args, int);
//                    put_int(num);
//                    count++;
//                    break;
//                }
//                case 's': {
//                    const char *str = va_arg(args, const char *);
//                    put_string(str);
//                    count += strlen(str);
//                    break;
//                }
//                case 'c': {
//                    char c = (char)va_arg(args, int);
//                    add_to_buffer(c);
//                    count++;
//                    break;
//                }
//                case 'f': {
//                    double num = va_arg(args, double);
//                    put_float(num, precision);
//                    count++;
//                    break;
//                }
//                default:
//                    add_to_buffer(*format);
//                    count++;
//                    break;
//            }
//        } else {
//            add_to_buffer(*format);
//            count++;
//        }
//        format++;
//    }
//
//    flush_buffer();
//    va_end(args);
//    return count;
//}

// 示例的串口发送函数实现
void uart_send_char(char c) {
        while (!ScibRegs.LSR.bit.THRE)
            ;
        ScibRegs.THR = c;
        while (!ScibRegs.LSR.bit.TEMT)
            ;
}

void uart_send_string(const char *str, int len) {
    for (int i = 0; i < len; i++) {
        uart_send_char(str[i]);
    }
}

